diff --git a/system/application/config/config.php b/system/application/config/config.php
index f8fd9c8..da79797 100644
--- a/system/application/config/config.php
+++ b/system/application/config/config.php
@@ -149,7 +149,7 @@
 |
 */
 $config['enable_query_strings'] = FALSE;
-$config['directory_trigger'] = 'd';	 // experimental not currently in use
+$config['directory_trigger'] = 'd'; // experimental not currently in use
 $config['controller_trigger'] = 'c';
 $config['function_trigger'] = 'm';
 
diff --git a/system/application/config/constants.php b/system/application/config/constants.php
index 55dc6b7..3d317f5 100644
--- a/system/application/config/constants.php
+++ b/system/application/config/constants.php
@@ -29,7 +29,7 @@
 
 define('FOPEN_READ', 							'rb');
 define('FOPEN_READ_WRITE',						'r+b');
-define('FOPEN_WRITE_CREATE_DESTRUCTIVE', 		'wb');	// truncates existing file data, use with care
+define('FOPEN_WRITE_CREATE_DESTRUCTIVE', 		'wb'); // truncates existing file data, use with care
 define('FOPEN_READ_WRITE_CREATE_DESTRUCTIVE', 	'w+b'); // truncates existing file data, use with care
 define('FOPEN_WRITE_CREATE', 					'ab');
 define('FOPEN_READ_WRITE_CREATE', 				'a+b');
diff --git a/system/application/config/user_agents.php b/system/application/config/user_agents.php
index d350af3..38bfc1f 100644
--- a/system/application/config/user_agents.php
+++ b/system/application/config/user_agents.php
@@ -163,12 +163,12 @@
 $robots = array(
 					'googlebot'			=> 'Googlebot',
 					'msnbot'			=> 'MSNBot',
-					'slurp'			    => 'Inktomi Slurp',
-					'yahoo'			    => 'Yahoo',
+					'slurp'				=> 'Inktomi Slurp',
+					'yahoo'				=> 'Yahoo',
 					'askjeeves'			=> 'AskJeeves',
 					'fastcrawler'		=> 'FastCrawler',
 					'infoseek'			=> 'InfoSeek Robot 1.0',
-					'lycos'			    => 'Lycos'
+					'lycos'				=> 'Lycos'
 				);
 
 /* End of file user_agents.php */
diff --git a/system/codeigniter/Common.php b/system/codeigniter/Common.php
index b0df529..8f4f9a9 100644
--- a/system/codeigniter/Common.php
+++ b/system/codeigniter/Common.php
@@ -93,16 +93,16 @@
 	// folder we'll load the native class from the system/libraries folder.	
 	if (file_exists(APPPATH.'libraries/'.config_item('subclass_prefix').$class.EXT))
 	{
-		require(BASEPATH.'libraries/'.$class.EXT);	
+		require(BASEPATH.'libraries/'.$class.EXT);
 		require(APPPATH.'libraries/'.config_item('subclass_prefix').$class.EXT);
-		$is_subclass = TRUE;	
+		$is_subclass = TRUE;
 	}
 	else
 	{
 		if (file_exists(APPPATH.'libraries/'.$class.EXT))
 		{
-			require(APPPATH.'libraries/'.$class.EXT);	
-			$is_subclass = FALSE;	
+			require(APPPATH.'libraries/'.$class.EXT);
+			$is_subclass = FALSE;
 		}
 		else
 		{
@@ -241,7 +241,7 @@
 		return;
 	}
 
-	$LOG =& load_class('Log');	
+	$LOG =& load_class('Log');
 	$LOG->write_log($level, $message, $php_error);
 }
 
diff --git a/system/database/DB.php b/system/database/DB.php
index eb25273..ef67c80 100644
--- a/system/database/DB.php
+++ b/system/database/DB.php
@@ -44,8 +44,7 @@
 			show_error('You have specified an invalid database connection group.');
 		}
 		
-		$params = $db[$active_group];			
-	}
+		$params = $db[$active_group]		}
 	elseif (is_string($params))
 	{
 		
diff --git a/system/database/DB_driver.php b/system/database/DB_driver.php
index 60f51d7..1678cff 100644
--- a/system/database/DB_driver.php
+++ b/system/database/DB_driver.php
@@ -142,7 +142,7 @@
 						{
 							$this->display_error('db_unable_to_create', $this->database);
 						}
-						return FALSE;				
+						return FALSE;
 					}
 					else
 					{
@@ -221,7 +221,7 @@
 			{
 				return $this->display_error('db_unsupported_function');
 			}
-			return FALSE;		
+			return FALSE;
 		}
 		
 		if ($this->dbdriver == 'oci8')
@@ -258,7 +258,7 @@
 				log_message('error', 'Invalid query: '.$sql);
 				return $this->display_error('db_invalid_query');
 			}
-			return FALSE;		
+			return FALSE;
 		}
 
 		// Verify table prefix and replace if necessary
@@ -543,12 +543,12 @@
 				$this->_trans_status = TRUE;
 			}
 
-			log_message('debug', 'DB Transaction Failure');			
-			return FALSE;			
+			log_message('debug', 'DB Transaction Failure');
+			return FALSE;
 		}
 		
 		$this->trans_commit();
-		return TRUE;	
+		return TRUE;
 	}
 
 	// --------------------------------------------------------------------
@@ -755,7 +755,7 @@
 			{
 				return $this->display_error('db_unsupported_function');
 			}
-			return FALSE;		
+			return FALSE;
 		}
 
 		$retval = array();
@@ -815,7 +815,7 @@
 			{
 				return $this->display_error('db_field_param_missing');
 			}
-			return FALSE;			
+			return FALSE;
 		}
 		
 		if (FALSE === ($sql = $this->_list_columns($this->prep_tablename($table))))
@@ -824,7 +824,7 @@
 			{
 				return $this->display_error('db_unsupported_function');
 			}
-			return FALSE;		
+			return FALSE;
 		}
 		
 		$query = $this->query($sql);
@@ -887,7 +887,7 @@
 			{
 				return $this->display_error('db_field_param_missing');
 			}
-			return FALSE;			
+			return FALSE;
 		}
 		
 		$query = $this->query($this->_field_data($this->prep_tablename($table)));
@@ -906,7 +906,7 @@
 	 */	
 	function insert_string($table, $data)
 	{
-		$fields = array();	
+		$fields = array();
 		$values = array();
 		
 		foreach($data as $key => $val)
@@ -1039,7 +1039,7 @@
 			{
 				return $this->display_error('db_unsupported_function');
 			}
-			return FALSE;			
+			return FALSE;
 		}
 		else
 		{
diff --git a/system/database/DB_result.php b/system/database/DB_result.php
index d8d0d0d..2a7824f 100644
--- a/system/database/DB_result.php
+++ b/system/database/DB_result.php
@@ -104,7 +104,7 @@
 			return array();
 		}
 
-		$this->_data_seek(0);			
+		$this->_data_seek(0);
 		while ($row = $this->_fetch_assoc())
 		{
 			$this->result_array[] = $row;
diff --git a/system/database/drivers/mysql/mysql_driver.php b/system/database/drivers/mysql/mysql_driver.php
index 8df6c1b..889ea17 100644
--- a/system/database/drivers/mysql/mysql_driver.php
+++ b/system/database/drivers/mysql/mysql_driver.php
@@ -246,15 +246,15 @@
 	function escape_str($str)	
 	{	
 		if (is_array($str))
-    	{
-    		foreach($str as $key => $val)
-    		{
-    			$str[$key] = $this->escape_str($val);
-    		}
-    		
-    		return $str;
-    	}
-	
+		{
+			foreach($str as $key => $val)
+	   		{
+				$str[$key] = $this->escape_str($val);
+	   		}
+   		
+	   		return $str;
+	   	}
+
 		if (function_exists('mysql_real_escape_string') AND is_resource($this->conn_id))
 		{
 			return mysql_real_escape_string($str, $this->conn_id);
diff --git a/system/database/drivers/oci8/oci8_result.php b/system/database/drivers/oci8/oci8_result.php
index 73373c8..20ab925 100644
--- a/system/database/drivers/oci8/oci8_result.php
+++ b/system/database/drivers/oci8/oci8_result.php
@@ -42,13 +42,15 @@
 	 */
 	function num_rows()
 	{
-        $rowcount = count($this->result_array());
-        @ociexecute($this->stmt_id);
-        if ($this->curs_id)
+		$rowcount = count($this->result_array());
+		@ociexecute($this->stmt_id);
+
+		if ($this->curs_id)
 		{
 			@ociexecute($this->curs_id);
 		}
-        return $rowcount;
+
+		return $rowcount;
 	}
 
 	// --------------------------------------------------------------------
diff --git a/system/helpers/file_helper.php b/system/helpers/file_helper.php
index 86c5c09..b59443c 100644
--- a/system/helpers/file_helper.php
+++ b/system/helpers/file_helper.php
@@ -262,60 +262,60 @@
 * Options are: name, server_path, size, date, readable, writable, executable, fileperms
 * Returns FALSE if the file cannot be found.
 *
-* @access    public
-* @param    string    path to file
-* @param    mixed    array or comma separated string of information returned
-* @return    array
-*/    
+* @access	public
+* @param	string		path to file
+* @param	mixed		array or comma separated string of information returned
+* @return	array
+*/
 if ( ! function_exists('get_file_info'))
 {
-    function get_file_info($file, $returned_values = array('name', 'server_path', 'size', 'date'))
-    {
+	function get_file_info($file, $returned_values = array('name', 'server_path', 'size', 'date'))
+	{
 
-        if ( ! file_exists($file))
-        {
-            return FALSE;
-        }
+		if ( ! file_exists($file))
+		{
+			return FALSE;
+		}
 
-        if (is_string($returned_values))
-        {
-            $returned_values = explode(',', $returned_values);
-        }
+		if (is_string($returned_values))
+		{
+			$returned_values = explode(',', $returned_values);
+		}
 
-        foreach ($returned_values as $key)
-        {
-            switch ($key)
-            {
-                case 'name':
-                    $fileinfo['name'] = substr(strrchr($file, '/'), 1);
-                    break;
-                case 'server_path':
-                    $fileinfo['server_path'] = $file;
-                    break;
-                case 'size':
-                    $fileinfo['size'] = filesize($file);
-                    break;
-                case 'date':
-                    $fileinfo['date'] = filectime($file);
-                    break;
-                case 'readable':
-                    $fileinfo['readable'] = is_readable($file);
-                    break;
-                case 'writable':
-                    // There are known problems using is_weritable on IIS.  It may not be reliable - consider fileperms()
-                    $fileinfo['writable'] = is_writable($file);
-                    break;
-                case 'executable':
-                    $fileinfo['executable'] = is_executable($file);
-                    break;
-                case 'fileperms':
-                    $fileinfo['fileperms'] = fileperms($file);
-                    break;
-            }
-        }
+		foreach ($returned_values as $key)
+		{
+			switch ($key)
+			{
+				case 'name':
+					$fileinfo['name'] = substr(strrchr($file, '/'), 1);
+					break;
+				case 'server_path':
+					$fileinfo['server_path'] = $file;
+					break;
+				case 'size':
+					$fileinfo['size'] = filesize($file);
+					break;
+				case 'date':
+					$fileinfo['date'] = filectime($file);
+					break;
+				case 'readable':
+					$fileinfo['readable'] = is_readable($file);
+					break;
+				case 'writable':
+					// There are known problems using is_weritable on IIS.  It may not be reliable - consider fileperms()
+					$fileinfo['writable'] = is_writable($file);
+					break;
+				case 'executable':
+					$fileinfo['executable'] = is_executable($file);
+					break;
+				case 'fileperms':
+					$fileinfo['fileperms'] = fileperms($file);
+					break;
+			}
+		}
 
-        return $fileinfo;
-    }
+		return $fileinfo;
+	}
 }
 
 // --------------------------------------------------------------------
diff --git a/system/helpers/form_helper.php b/system/helpers/form_helper.php
index 0ad57d5..0c74ac0 100644
--- a/system/helpers/form_helper.php
+++ b/system/helpers/form_helper.php
@@ -53,7 +53,7 @@
 
 		$form = '<form action="'.$action.'"';
 	
-        $form .= _attributes_to_string($attributes, TRUE);
+		$form .= _attributes_to_string($attributes, TRUE);
 	
 		$form .= '>';
 
@@ -214,11 +214,11 @@
 	{
 		$defaults = array('name' => (( ! is_array($data)) ? $data : ''), 'cols' => '90', 'rows' => '12');
 	
-	    if ( ! is_array($data) OR ! isset($data['value']))
+		if ( ! is_array($data) OR ! isset($data['value']))
 		{
 			$val = $value;
 		}
-	    else
+		else
 		{
 			$val = $data['value']; 
 			unset($data['value']); // textareas don't use the value attribute
@@ -466,7 +466,7 @@
 	{
 		$fieldset = "<fieldset";
 
-        $fieldset .= _attributes_to_string($attributes, FALSE);
+		$fieldset .= _attributes_to_string($attributes, FALSE);
 	
 		$fieldset .= ">\n";
 	
@@ -623,8 +623,8 @@
 		   {
 			  $attributes .= ' method="post"';
 		   }
-		   
-		   return ' '.$attributes;       
+
+		   return ' '.$attributes;
 	   }
 	
 	   if (is_object($attributes) AND count($attributes) > 0)
diff --git a/system/helpers/inflector_helper.php b/system/helpers/inflector_helper.php
index 49ba542..e362a3f 100644
--- a/system/helpers/inflector_helper.php
+++ b/system/helpers/inflector_helper.php
@@ -41,28 +41,28 @@
 {	
 	function singular($str)
 	{
-	    $str = strtolower(trim($str));
-	    $end = substr($str, -3);
-    
-	    if ($end == 'ies')
-	    {
-	        $str = substr($str, 0, strlen($str)-3).'y';
-	    }
-	    elseif ($end == 'ses')
-	    {
-	        $str = substr($str, 0, strlen($str)-2);
-	    }
-	    else
-	    {
-	        $end = substr($str, -1);
-        
-	        if ($end == 's')
-	        {
-	            $str = substr($str, 0, strlen($str)-1);
-	        }
-	    }
-    
-	    return $str;
+		$str = strtolower(trim($str));
+		$end = substr($str, -3);
+	
+		if ($end == 'ies')
+		{
+			$str = substr($str, 0, strlen($str)-3).'y';
+		}
+		elseif ($end == 'ses')
+		{
+			$str = substr($str, 0, strlen($str)-2);
+		}
+		else
+		{
+			$end = substr($str, -1);
+		
+			if ($end == 's')
+			{
+				$str = substr($str, 0, strlen($str)-1);
+			}
+		}
+	
+		return $str;
 	}
 }
 
@@ -82,26 +82,26 @@
 {	
 	function plural($str, $force = FALSE)
 	{
-	    $str = strtolower(trim($str));
-	    $end = substr($str, -1);
+		$str = strtolower(trim($str));
+		$end = substr($str, -1);
 
-	    if ($end == 'y')
-	    {
-	        $str = substr($str, 0, strlen($str)-1).'ies';
-	    }
-	    elseif ($end == 's')
-	    {
-	        if ($force == TRUE)
-	        {
-	            $str .= 'es';
-	        }
-	    }
-	    else
-	    {
-	        $str .= 's';
-	    }
+		if ($end == 'y')
+		{
+			$str = substr($str, 0, strlen($str)-1).'ies';
+		}
+		elseif ($end == 's')
+		{
+			if ($force == TRUE)
+			{
+				$str .= 'es';
+			}
+		}
+		else
+		{
+			$str .= 's';
+		}
 
-	    return $str;
+		return $str;
 	}
 }
 
diff --git a/system/helpers/smiley_helper.php b/system/helpers/smiley_helper.php
index 8f75437..efa3384 100644
--- a/system/helpers/smiley_helper.php
+++ b/system/helpers/smiley_helper.php
@@ -36,7 +36,7 @@
  * @param	string	form name
  * @param	string	field name
  * @return	string
- */	
+ */
 if ( ! function_exists('js_insert_smiley'))
 {
 	function js_insert_smiley($form_name = '', $form_field = '')
@@ -49,7 +49,7 @@
 	}
 </script>
 EOF;
-	}	
+	}
 }
 // ------------------------------------------------------------------------
 
@@ -62,7 +62,7 @@
  * @access	public
  * @param	string	the URL to the folder containing the smiley images
  * @return	array
- */	
+ */
 if ( ! function_exists('get_clickable_smileys'))
 {
 	function get_clickable_smileys($image_url = '', $smileys = NULL)
@@ -72,12 +72,12 @@
 			if (FALSE === ($smileys = _get_smiley_array()))
 			{
 				return $smileys;
-			}        
+			}
 		}
 
 		// Add a trailing slash to the file path if needed
 		$image_url = preg_replace("/(.+?)\/*$/", "\\1/",  $image_url);
-	
+
 		$used = array();
 		foreach ($smileys as $key => $val)
 		{
@@ -89,12 +89,12 @@
 			{
 				continue;
 			}
-	
-			$link[] = "<a href=\"javascript:void(0);\" onClick=\"insert_smiley('".$key."')\"><img src=\"".$image_url.$smileys[$key][0]."\" width=\"".$smileys[$key][1]."\" height=\"".$smileys[$key][2]."\" alt=\"".$smileys[$key][3]."\" style=\"border:0;\" /></a>";	
-	
+
+			$link[] = "<a href=\"javascript:void(0);\" onClick=\"insert_smiley('".$key."')\"><img src=\"".$image_url.$smileys[$key][0]."\" width=\"".$smileys[$key][1]."\" height=\"".$smileys[$key][2]."\" alt=\"".$smileys[$key][3]."\" style=\"border:0;\" /></a>";
+
 			$used[$smileys[$key][0]] = TRUE;
 		}
-	
+
 		return $link;
 	}
 }
@@ -110,7 +110,7 @@
  * @param	string	the text to be parsed
  * @param	string	the URL to the folder containing the smiley images
  * @return	string
- */	
+ */
 if ( ! function_exists('parse_smileys'))
 {
 	function parse_smileys($str = '', $image_url = '', $smileys = NULL)
@@ -125,17 +125,17 @@
 			if (FALSE === ($smileys = _get_smiley_array()))
 			{
 				return $str;
-			}        
+			}
 		}
-	
+
 		// Add a trailing slash to the file path if needed
 		$image_url = preg_replace("/(.+?)\/*$/", "\\1/",  $image_url);
 
 		foreach ($smileys as $key => $val)
-		{        
+		{
 			$str = str_replace($key, "<img src=\"".$image_url.$smileys[$key][0]."\" width=\"".$smileys[$key][1]."\" height=\"".$smileys[$key][2]."\" alt=\"".$smileys[$key][3]."\" style=\"border:0;\" />", $str);
 		}
-	
+
 		return $str;
 	}
 }
@@ -149,7 +149,7 @@
  *
  * @access	private
  * @return	mixed
- */	
+ */
 if ( ! function_exists('_get_smiley_array'))
 {
 	function _get_smiley_array()
@@ -160,12 +160,12 @@
 		}
 
 		include(APPPATH.'config/smileys'.EXT);
-	
+
 		if ( ! isset($smileys) OR ! is_array($smileys))
 		{
 			return FALSE;
 		}
-	
+
 		return $smileys;
 	}
 }
diff --git a/system/helpers/string_helper.php b/system/helpers/string_helper.php
index 7b6becf..d85d76c 100644
--- a/system/helpers/string_helper.php
+++ b/system/helpers/string_helper.php
@@ -46,7 +46,7 @@
 {
 	function trim_slashes($str)
 	{
-	    return trim($str, '/');
+		return trim($str, '/');
 	} 
 }
 	
@@ -173,7 +173,7 @@
 		{
 			$str = trim($str, $character);
 		}
-    
+
 		return $str;
 	}
 }
diff --git a/system/libraries/Controller.php b/system/libraries/Controller.php
index 5c96c57..f9c6bd2 100644
--- a/system/libraries/Controller.php
+++ b/system/libraries/Controller.php
@@ -87,12 +87,12 @@
 			
 			// sync up the objects since PHP4 was working from a copy
 			foreach (array_keys(get_object_vars($this)) as $attribute)
-            {
-                if (is_object($this->$attribute))
-                {
-                    $this->load->$attribute =& $this->$attribute;
-                }
-            }
+			{
+				if (is_object($this->$attribute))
+				{
+					$this->load->$attribute =& $this->$attribute;
+				}
+			}
 		}
 	}
 	
diff --git a/system/libraries/Email.php b/system/libraries/Email.php
index b0d9f12..ca1093a 100644
--- a/system/libraries/Email.php
+++ b/system/libraries/Email.php
@@ -1169,7 +1169,7 @@
 		// Standardize newlines
 		if (strpos($str, "\r") !== FALSE)
 		{
-			$str = str_replace(array("\r\n", "\r"), "\n", $str);			
+			$str = str_replace(array("\r\n", "\r"), "\n", $str);	
 		}
 
 		// We are intentionally wrapping so mail servers will encode characters
@@ -1179,8 +1179,8 @@
 		// Break into an array of lines
 		$lines = explode("\n", $str);
 
-	    $escape = '=';
-	    $output = '';
+		$escape = '=';
+		$output = '';
 
 		foreach ($lines as $line)
 		{
diff --git a/system/libraries/Session.php b/system/libraries/Session.php
index 9907ade..9fad08c 100644
--- a/system/libraries/Session.php
+++ b/system/libraries/Session.php
@@ -69,10 +69,10 @@
 		$this->CI->load->helper('string');
 
 		// Do we need encryption? If so, load the encryption class
-		if ($this->sess_encrypt_cookie == TRUE)	
+		if ($this->sess_encrypt_cookie == TRUE)
 		{
 			$this->CI->load->library('encrypt');
-		}		
+		}
 
 		// Are we using a database?  If so, load it
 		if ($this->sess_use_database === TRUE AND $this->sess_table_name != '')
@@ -106,10 +106,10 @@
 		}
 		
 		// Delete 'old' flashdata (from last request)
-       	$this->_flashdata_sweep();
-        
-        // Mark all new flashdata as old (data will be deleted before next request)
-       	$this->_flashdata_mark();
+	   	$this->_flashdata_sweep();
+		
+		// Mark all new flashdata as old (data will be deleted before next request)
+	   	$this->_flashdata_mark();
 
 		// Delete expired sessions if necessary
 		$this->_sess_gc();
@@ -361,7 +361,7 @@
 		// Turn it into a hash
 		$new_sessid = md5(uniqid($new_sessid, TRUE));
 		
-        // Update the session data in the session data array
+		// Update the session data in the session data array
 		$this->userdata['session_id'] = $new_sessid;
 		$this->userdata['last_activity'] = $this->now;
 		
@@ -427,7 +427,7 @@
 	 */	
 	function all_userdata()
 	{
-        return ( ! isset($this->userdata)) ? FALSE : $this->userdata;
+		return ( ! isset($this->userdata)) ? FALSE : $this->userdata;
 	}
 	
 	// --------------------------------------------------------------------
@@ -484,9 +484,9 @@
 		$this->sess_write();
 	}
 	
-    // ------------------------------------------------------------------------
+	// ------------------------------------------------------------------------
 
-    /**
+	/**
 	 * Add or change flashdata, only available
 	 * until the next request
 	 *
@@ -495,46 +495,46 @@
 	 * @param	string
 	 * @return	void
 	 */
-    function set_flashdata($newdata = array(), $newval = '')
-    {
-        if (is_string($newdata))
-        {
-            $newdata = array($newdata => $newval);
-        }
-        
-        if (count($newdata) > 0)
-        {
-            foreach ($newdata as $key => $val)
-            {
-                $flashdata_key = $this->flashdata_key.':new:'.$key;
-                $this->set_userdata($flashdata_key, $val);
-            }
-        }
-    } 
+	function set_flashdata($newdata = array(), $newval = '')
+	{
+		if (is_string($newdata))
+		{
+			$newdata = array($newdata => $newval);
+		}
+		
+		if (count($newdata) > 0)
+		{
+			foreach ($newdata as $key => $val)
+			{
+				$flashdata_key = $this->flashdata_key.':new:'.$key;
+				$this->set_userdata($flashdata_key, $val);
+			}
+		}
+	} 
 	
-    // ------------------------------------------------------------------------
+	// ------------------------------------------------------------------------
 
-    /**
-     * Keeps existing flashdata available to next request.
+	/**
+	 * Keeps existing flashdata available to next request.
 	 *
 	 * @access	public
 	 * @param	string
 	 * @return	void
-     */
-    function keep_flashdata($key)
-    {
+	 */
+	function keep_flashdata($key)
+	{
 		// 'old' flashdata gets removed.  Here we mark all 
 		// flashdata as 'new' to preserve it from _flashdata_sweep()
 		// Note the function will return FALSE if the $key 
 		// provided cannot be found
-        $old_flashdata_key = $this->flashdata_key.':old:'.$key;
-        $value = $this->userdata($old_flashdata_key);
+		$old_flashdata_key = $this->flashdata_key.':old:'.$key;
+		$value = $this->userdata($old_flashdata_key);
 
-        $new_flashdata_key = $this->flashdata_key.':new:'.$key;
-        $this->set_userdata($new_flashdata_key, $value);
-    }
+		$new_flashdata_key = $this->flashdata_key.':new:'.$key;
+		$this->set_userdata($new_flashdata_key, $value);
+	}
 	
-    // ------------------------------------------------------------------------
+	// ------------------------------------------------------------------------
 
 	/**
 	 * Fetch a specific flashdata item from the session array
@@ -543,57 +543,57 @@
 	 * @param	string
 	 * @return	string
 	 */	
-    function flashdata($key)
-    {
-        $flashdata_key = $this->flashdata_key.':old:'.$key;
-        return $this->userdata($flashdata_key);
-    }
+	function flashdata($key)
+	{
+		$flashdata_key = $this->flashdata_key.':old:'.$key;
+		return $this->userdata($flashdata_key);
+	}
 
-    // ------------------------------------------------------------------------
+	// ------------------------------------------------------------------------
 
-    /**
-     * Identifies flashdata as 'old' for removal
+	/**
+	 * Identifies flashdata as 'old' for removal
 	 * when _flashdata_sweep() runs.
 	 *
 	 * @access	private
 	 * @return	void
-     */
-    function _flashdata_mark()
-    {
+	 */
+	function _flashdata_mark()
+	{
 		$userdata = $this->all_userdata();
-        foreach ($userdata as $name => $value)
-        {
-            $parts = explode(':new:', $name);
-            if (is_array($parts) && count($parts) === 2)
-            {
-                $new_name = $this->flashdata_key.':old:'.$parts[1];
-                $this->set_userdata($new_name, $value);
-                $this->unset_userdata($name);
-            }
-        }
-    }
+		foreach ($userdata as $name => $value)
+		{
+			$parts = explode(':new:', $name);
+			if (is_array($parts) && count($parts) === 2)
+			{
+				$new_name = $this->flashdata_key.':old:'.$parts[1];
+				$this->set_userdata($new_name, $value);
+				$this->unset_userdata($name);
+			}
+		}
+	}
 
-    // ------------------------------------------------------------------------
+	// ------------------------------------------------------------------------
 
-    /**
-     * Removes all flashdata marked as 'old'
+	/**
+	 * Removes all flashdata marked as 'old'
 	 *
 	 * @access	private
 	 * @return	void
-     */
+	 */
 
-    function _flashdata_sweep()
-    {
+	function _flashdata_sweep()
+	{
 		$userdata = $this->all_userdata();
-        foreach ($userdata as $key => $value)
-        {
-            if (strpos($key, ':old:'))
-            {
-                $this->unset_userdata($key);
-            }
-        }
+		foreach ($userdata as $key => $value)
+		{
+			if (strpos($key, ':old:'))
+			{
+				$this->unset_userdata($key);
+			}
+		}
 
-    }
+	}
 
 	// --------------------------------------------------------------------
 	
diff --git a/system/libraries/Upload.php b/system/libraries/Upload.php
index 25e1435..4a61535 100644
--- a/system/libraries/Upload.php
+++ b/system/libraries/Upload.php
@@ -836,7 +836,7 @@
 	 * Prep Filename
 	 *
 	 * Prevents possible script execution from Apache's handling of files multiple extensions
-     * http://httpd.apache.org/docs/1.3/mod/mod_mime.html#multipleext
+	 * http://httpd.apache.org/docs/1.3/mod/mod_mime.html#multipleext
 	 *
 	 * @access	private
 	 * @param	string
diff --git a/system/libraries/Validation.php b/system/libraries/Validation.php
index cae1a3f..b42d0e0 100644
--- a/system/libraries/Validation.php
+++ b/system/libraries/Validation.php
@@ -640,17 +640,17 @@
 	 */
 	function is_natural_no_zero($str)
 	{   
-    	if ( ! preg_match( '/^[0-9]+$/', $str))
-    	{
-    		return FALSE;
-    	}
-    	
-    	if ($str == 0)
-    	{
-    		return FALSE;
-    	}
-    
-   		return TRUE;
+		if ( ! preg_match( '/^[0-9]+$/', $str))
+		{
+			return FALSE;
+		}
+	
+		if ($str == 0)
+		{
+			return FALSE;
+		}
+
+		return TRUE;
 	}
 
 	// --------------------------------------------------------------------
diff --git a/system/libraries/Zip.php b/system/libraries/Zip.php
index 8958b57..6ca9cfb 100644
--- a/system/libraries/Zip.php
+++ b/system/libraries/Zip.php
@@ -34,8 +34,8 @@
 
 	var $zipdata 	= '';
 	var $directory 	= '';
-    var $entries 	= 0;
-    var $file_num 	= 0;
+	var $entries 	= 0;
+	var $file_num 	= 0;
 	var $offset		= 0;
 
 	function CI_Zip()
@@ -320,16 +320,16 @@
 	 */
 	function download($filename = 'backup.zip')
 	{
-        if ( ! preg_match("|.+?\.zip$|", $filename))
-        {
-            $filename .= '.zip';
-        }
+		if ( ! preg_match("|.+?\.zip$|", $filename))
+		{
+			$filename .= '.zip';
+		}
 
-        $zip_content =& $this->get_zip();
+		$zip_content =& $this->get_zip();
 
-        $CI =& get_instance();
-        $CI->load->helper('download');
-		
+		$CI =& get_instance();
+		$CI->load->helper('download');
+
 		force_download($filename, $zip_content);
 	}
 
@@ -346,11 +346,11 @@
 	 */		
 	function clear_data()
 	{
-		$this->zipdata   = '';
-		$this->directory = '';
-		$this->entries   = 0;
-		$this->file_num  = 0;
-		$this->offset    = 0;
+		$this->zipdata		= '';
+		$this->directory	= '';
+		$this->entries		= 0;
+		$this->file_num		= 0;
+		$this->offset		= 0;
 	}
 	
 }
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 02cb2fc..ed10c47 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -63,6 +63,14 @@
 SVN Revision: XXXX</p>
 
 <ul>
+	<li>Libraries
+		<ul>
+			<li>Updated the <a href="libraries/sessions.html">Sessions class</a> so that any custom data being saved gets stored to a database rather than the session cookie (assuming you are using a database to store session data), permitting much more data to be saved.</li>
+			<li>Added the ability to store libraries in subdirectories within either the main "libraries" or the local application "libraries" folder. Please see the <a href="libraries/loader.html">Loader class</a> for more info. </li>
+			<li>Changed the output of the profiler to use style attribute rather then clear, and added the id "codeigniter_profiler" to the container div</li>
+			<li>Added <kbd>is_natural()</kbd> and <kbd>is_natural_no_zero()</kbd> to the <a href="libraries/validation.html">Validation class</a>.</li>
+		</ul>
+	</li>
 	<li>Helpers
 		<ul>
 			<li>Added current_url() and uri_segments() to  <a href="helpers/url_helper.html">URL helper</a>.</li>
@@ -72,15 +80,6 @@
 			<li>Updated Date Helper to match the world's current time zones and offsets.</li>
 		</ul>
 	</li>
-	<li>Libraries
-		<ul>
-			<li>Updated the <a href="libraries/sessions.html">Sessions class</a> so that any custom data being saved gets stored to a database rather than the session cookie (assuming you are using a database to store session data), permitting much more data to be saved.</li>
-			<li>Added the ability to store libraries in subdirectories within either the main "libraries" or the local application "libraries" folder. Please see the <a href="libraries/loader.html">Loader class</a> for more info. </li>
-			<li>Changed the output of the profiler to use style attribute rather then clear, and added the id "codeigniter_profiler" to the container div</li>
-			<li>Added <kbd>is_natural()</kbd> and <kbd>is_natural_no_zero()</kbd> to the <a href="libraries/validation.html">Validation class</a>.</li>
-		</ul>
-	</li>
-
 	<li>Other changes
 		<ul>
 			<li>Improved performance and accuracy of xss_clean(), including reduction of false positives on image/file tests.</li>
@@ -155,39 +154,39 @@
 	<li>Fixed assorted user guide typos or examples (#4574, #4706).</li>
 	<li>Added quoted-printable headers to Email class when the multi-part override is used.</li>
 	<li>Fixed a double opening &lt;p&gt; tag in the index pages of each system directory.</li>
-	</ul>
+</ul>
 
 <h2>Version 1.6.2</h2>
 <p>Release Date: May 13, 2008<br />
 SVN Revision: 1155</p>
 <ul>
-    <li>Active Record
-    	<ul>
-    		<li>Added the ability to prevent escaping in <kbd>having()</kbd> clauses.</li>
-    		<li>Added <kbd>rename_table()</kbd> into <a href="./database/forge.html">DBForge</a>.</li>
-    		<li>Fixed a bug that wasn't allowing escaping to be turned off if the value of a query was NULL.</li>
-    		<li>DB Forge is now assigned to any models that exist after loading (#3457).</li>
-    		</ul>
-    </li>
-    <li>Database
-    	<ul>
-    		<li>Added <a href="./database/transactions.html">Strict Mode</a> to database transactions.</li>
-			<li>Escape behaviour in where() clauses has changed; values in those with the &quot;FALSE&quot; argument are no longer escaped (ie: quoted).</li>
-    	</ul>
+	<li>Active Record
+		<ul>
+			<li>Added the ability to prevent escaping in <kbd>having()</kbd> clauses.</li>
+			<li>Added <kbd>rename_table()</kbd> into <a href="./database/forge.html">DBForge</a>.</li>
+			<li>Fixed a bug that wasn't allowing escaping to be turned off if the value of a query was NULL.</li>
+			<li>DB Forge is now assigned to any models that exist after loading (#3457).</li>
+			</ul>
 	</li>
-    <li>Config
-    	<ul>
-    		<li>Added 'application/vnd.ms-powerpoint' to list of mime types.</li>
-    		<li>Added 'audio/mpg' to list of mime types.</li>
+	<li>Database
+		<ul>
+			<li>Added <a href="./database/transactions.html">Strict Mode</a> to database transactions.</li>
+			<li>Escape behaviour in where() clauses has changed; values in those with the &quot;FALSE&quot; argument are no longer escaped (ie: quoted).</li>
+		</ul>
+	</li>
+	<li>Config
+		<ul>
+			<li>Added 'application/vnd.ms-powerpoint' to list of mime types.</li>
+			<li>Added 'audio/mpg' to list of mime types.</li>
 			<li>Added new user-modifiable file constants.php containing file mode and fopen constants.</li>
-    		<li>Added the ability to set CRLF settings via config in the <a href="libraries/email.html">Email</a> class.</li>
-    	</ul>
-    </li>
+			<li>Added the ability to set CRLF settings via config in the <a href="libraries/email.html">Email</a> class.</li>
+		</ul>
+	</li>
 	<li>Libraries
 		<ul>
 			<li>Added increased security for filename handling in the Upload library.</li>
 			<li>Added increased security for sessions for client-side data tampering.</li>
-    		<li>The MySQLi forge class is now in sync with MySQL forge. </li>
+			<li>The MySQLi forge class is now in sync with MySQL forge. </li>
 			<li>Added the ability to set CRLF settings via config in the <a href="libraries/email.html">Email</a> class.</li>
 			<li><a href="libraries/unit_testing.html">Unit Testing</a> results are now colour coded, and a change was made to the default template of results.</li>
 			<li>Added a valid_emails rule to the <a href="libraries/validation.html">Validation</a> class.</li>
@@ -195,7 +194,7 @@
 			<li>The <a href="libraries/zip.html">Zip class</a> has undergone a substantial re-write for speed and clarity (thanks stanleyxu for the hard work and code contribution in bug report #3425!)</li>
 		</ul>
 	</li>
-    <li>Helpers
+	<li>Helpers
 		<ul>
 			<li>Added a <a href="helpers/compatibility_helper.html">Compatibility Helper</a> for using some common PHP 5 functions safely in applications that might run on PHP 4 servers (thanks Seppo for the hard work and code contribution!)</li>
 			<li>Added <kbd>form_button()</kbd> in the <a href="helpers/form_helper.html">Form helper</a>.</li>
@@ -207,7 +206,7 @@
 			<li>Added <kbd>get_dir_file_info()</kbd>, <kbd>get_file_info()</kbd>, and <kbd>get_mime_by_extension()</kbd> to the <a href="helpers/file_helper.html">File Helper</a>.</li>
 			<li>Added <kbd>symbolic_permissions()</kbd> and <kbd>octal_permissions()</kbd> to the <a href='helpers/file_helper.html'>File helper</a>.</li>
 		</ul>
-    </li>
+	</li>
 	<li>Plugins
 		<ul>
 			<li>Modified captcha generation to first look for the function imagecreatetruecolor, and fallback to imagecreate if it isn't available (#4226).</li>
@@ -257,7 +256,7 @@
 	<li>Fixed an array to string conversion error in the Validation library (#4425)</li>
 	<li>Fixed bug (#4451, #4299, #4339) where failed transactions will not rollback when debug mode is enabled.</li>
 	<li>Fixed a bug (#4506) with overlay_watermark() in the Image library preventing support for PNG-24s with alpha transparency</li>
-    <li>Fixed assorted user guide typos (#3453, #4364, #4379, #4399, #4408, #4412, #4448, #4488).</li>
+	<li>Fixed assorted user guide typos (#3453, #4364, #4379, #4399, #4408, #4412, #4448, #4488).</li>
 	</ul>
 
 <h2>Version 1.6.1</h2>
@@ -279,7 +278,7 @@
 		<ul>
 			<li>Modified <kbd>xss_clean()</kbd> to be more intelligent with its handling of URL encoded strings.</li>
 			<li>Added $_SERVER, $_FILES, $_ENV, and $_SESSION to sanitization of globals.</li>
-		    <li>Added a <a href="./helpers/path_helper.html">Path Helper</a>.</li>
+			<li>Added a <a href="./helpers/path_helper.html">Path Helper</a>.</li>
 			<li>Simplified <kbd>_reindex_segments()</kbd> in the URI class.</li>
 			<li>Escaped the '-' in the default 'permitted_uri_chars' config item, to prevent errors if developers just try to add additional characters to the end of the default expression.</li>
 			<li>Modified method calling to controllers to show a 404 when a private or protected method is accessed via a URL.</li>
@@ -301,8 +300,8 @@
 	<li>Made Active Record fully database prefix aware (#3384).</li>
 	<li>Fixed a bug where DBForge was outputting invalid SQL in Postgres by adding brackets around the tables in FROM.</li>
 	<li>Changed the behaviour of Active Record's update() to make the WHERE clause optional (#3395).</li>
-    <li>Fixed a bug (#3396) where certain POST variables would cause a PHP warning.</li>
-    <li>Fixed a bug in query binding (#3402).</li>
+	<li>Fixed a bug (#3396) where certain POST variables would cause a PHP warning.</li>
+	<li>Fixed a bug in query binding (#3402).</li>
 	<li>Changed order of SQL keywords in the Profiler $highlight array so OR would not be highlighted before ORDER BY.</li>
 	<li>Fixed a bug (#3404) where the MySQLi driver was testing if $this->conn_id was a resource instead of an object.</li>
 	<li>Fixed a bug (#3419) connecting to a database via a DSN string.</li>
@@ -317,7 +316,7 @@
 <ul>
 	<li>DBForge
 		<ul>
-    		<li>Added <a href="./database/forge.html">DBForge</a> to the database tools.</li>
+			<li>Added <a href="./database/forge.html">DBForge</a> to the database tools.</li>
 			<li>Moved <kbd>create_database()</kbd> and <kbd>drop_database()</kbd> into <a href="./database/forge.html">DBForge</a>.</li>
 			<li>Added <kbd>add_field()</kbd>, <kbd>add_key()</kbd>, <kbd>create_table()</kbd>, <kbd>drop_table()</kbd>, <kbd>add_column()</kbd>, <kbd>drop_column()</kbd>, <kbd>modify_column()</kbd> into <a href="./database/forge.html">DBForge</a>.</li>
 		</ul>
@@ -326,16 +325,16 @@
 	<li>Active Record
 		<ul>
 			<li>Added <kbd>protect_identifiers()</kbd> in <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>All AR queries are backticked if appropriate to the database.</li>
+			<li>All AR queries are backticked if appropriate to the database.</li>
 			<li>Added <kbd>where_in()</kbd>, <kbd>or_where_in()</kbd>, <kbd>where_not_in()</kbd>,  <kbd>or_where_not_in()</kbd>, <kbd>not_like()</kbd> and <kbd>or_not_like()</kbd> to <a href="./database/active_record.html">Active Record</a>.</li>
 			<li>Added support for <kbd>limit()</kbd>  into <kbd>update()</kbd> and <kbd>delete()</kbd> statements in  <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>Added <kbd>empty_table()</kbd> and <kbd>truncate_table()</kbd> to <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>Added the ability to pass an array of tables to the <kbd>delete()</kbd> statement in <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>Added <kbd>count_all_results()</kbd> function to <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>Added <kbd>select_max()</kbd>, <kbd>select_min()</kbd>, <kbd>select_avg()</kbd> and <kbd>select_sum()</kbd> to <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>Added the ability to use aliases with joins in <a href="./database/active_record.html">Active Record</a>.</li>
-		    <li>Added a third parameter to Active Record's <kbd>like()</kbd> clause to control where the wildcard goes. </li>
-		    <li>Added a third parameter to <kbd>set()</kbd> in <a href="./database/active_record.html">Active Record</a> that withholds escaping data.</li>
+			<li>Added <kbd>empty_table()</kbd> and <kbd>truncate_table()</kbd> to <a href="./database/active_record.html">Active Record</a>.</li>
+			<li>Added the ability to pass an array of tables to the <kbd>delete()</kbd> statement in <a href="./database/active_record.html">Active Record</a>.</li>
+			<li>Added <kbd>count_all_results()</kbd> function to <a href="./database/active_record.html">Active Record</a>.</li>
+			<li>Added <kbd>select_max()</kbd>, <kbd>select_min()</kbd>, <kbd>select_avg()</kbd> and <kbd>select_sum()</kbd> to <a href="./database/active_record.html">Active Record</a>.</li>
+			<li>Added the ability to use aliases with joins in <a href="./database/active_record.html">Active Record</a>.</li>
+			<li>Added a third parameter to Active Record's <kbd>like()</kbd> clause to control where the wildcard goes. </li>
+			<li>Added a third parameter to <kbd>set()</kbd> in <a href="./database/active_record.html">Active Record</a> that withholds escaping data.</li>
 			<li>Changed the behaviour of variables submitted to the where() clause with no values to auto set &quot;IS NULL&quot;</li>
 		</ul>
 	</li>
@@ -347,8 +346,8 @@
 			<li>Added $this->db->dbprefix() to manually add database prefixes.</li>
 			<li>Added 'random' as an <kbd>order_by()</kbd> option , and removed &quot;rand()&quot; as a listed option as it was MySQL only.</li>
 			<li>Added a check for NULL fields in the MySQL database backup utility.</li>
-		    <li>Added &quot;constrain_by_prefix&quot; parameter to db-&gt;list_table() function.  If set to TRUE it will limit the result to only table names with the current prefix.</li>
-		    <li>Deprecated from Active Record; <kbd>getwhere()</kbd> for <kbd>get_where()</kbd>; <kbd>groupby()</kbd> for <kbd>group_by()</kbd>; <kbd>havingor()</kbd> for <kbd>having_or()</kbd>; <kbd>orderby()</kbd> for <kbd>order_by</kbd>; <kbd>orwhere()</kbd> for <kbd>or_where()</kbd>; and <kbd>orlike()</kbd> for <kbd>or_like()</kbd>.</li>
+			<li>Added &quot;constrain_by_prefix&quot; parameter to db-&gt;list_table() function.  If set to TRUE it will limit the result to only table names with the current prefix.</li>
+			<li>Deprecated from Active Record; <kbd>getwhere()</kbd> for <kbd>get_where()</kbd>; <kbd>groupby()</kbd> for <kbd>group_by()</kbd>; <kbd>havingor()</kbd> for <kbd>having_or()</kbd>; <kbd>orderby()</kbd> for <kbd>order_by</kbd>; <kbd>orwhere()</kbd> for <kbd>or_where()</kbd>; and <kbd>orlike()</kbd> for <kbd>or_like()</kbd>.</li>
 			<li>Modified <kbd>csv_from_result()</kbd> to output CSV data more in the spirit of basic rules of RFC 4180.</li>
 			<li>Added 'char_set' and 'dbcollat' database configuration settings, to explicitly set the client communication properly.</li>
 			<li>Removed 'active_r' configuration setting and replaced with a global $active_record setting, which is more
@@ -375,11 +374,11 @@
 			<li>Added Flashdata variables, session_id regeneration and configurable session update times to the <a href="./libraries/sessions.html">Session class.</a></li>
 			<li>Removed 'last_visit' from the Session class.</li>
 			<li>Added a language entry for valid_ip validation error.</li>
-		    <li>Modified prep_for_form() in the Validation class to accept arrays, adding support for POST array validation (via callbacks only)</li>
-		    <li>Added an &quot;integer&quot; rule into the <a href="./libraries/validation.html">Validation</a> library.</li>
+			<li>Modified prep_for_form() in the Validation class to accept arrays, adding support for POST array validation (via callbacks only)</li>
+			<li>Added an &quot;integer&quot; rule into the <a href="./libraries/validation.html">Validation</a> library.</li>
 			<li>Added valid_base64() to the <a href="./libraries/validation.html">Validation</a> library.</li>
-		    <li>Documented clear() in the <a href="../libraries/image_lib.html">Image Processing</a> library.</li>
-		    <li>Changed the behaviour of custom callbacks so that they no longer trigger the &quot;required&quot; rule. </li>
+			<li>Documented clear() in the <a href="../libraries/image_lib.html">Image Processing</a> library.</li>
+			<li>Changed the behaviour of custom callbacks so that they no longer trigger the &quot;required&quot; rule. </li>
 			<li>Modified Upload class $_FILES error messages to be more precise.</li>
 			<li>Moved the safe mode and auth checks for the Email library into the constructor. </li>
 			<li>Modified variable names in _ci_load() method of Loader class to avoid conflicts with view variables.</li>
@@ -394,18 +393,18 @@
 			<li>Added img() to the <a href="./helpers/html_helper.html">HTML helper.</a></li>
 			<li>Added ability to <a href="./general/helpers.html">"extend" Helpers</a>.</li>
 			<li>Added an <a href="./helpers/email_helper.html">email helper</a> into core helpers.</li>
-		    <li>Added <kbd>strip_quotes()</kbd> function to <a href="./helpers/string_helper.html">string helper</a>.</li>
-		    <li>Added <kbd>reduce_multiples()</kbd> function to <a href="./helpers/string_helper.html">string helper</a>.</li>
-		    <li>Added <kbd>quotes_to_entities()</kbd> function to <a href="./helpers/string_helper.html">string helper</a>.</li>
-		    <li>Added <kbd>form_fieldset()</kbd>, <kbd>form_fieldset_close()</kbd>, <kbd>form_label()</kbd>, and <kbd>form_reset()</kbd> function to <a href="./helpers/form_helper.html">form helper</a>.</li>
-		    <li>Added support for external urls in <kbd>form_open()</kbd>.</li>
-		    <li>Removed support for db_backup in MySQLi due to incompatible functions.</li>
-		    <li>Javascript Calendar plugin now uses the months and days from the calendar language file, instead of hard-coded values, internationalizing it.</li>
+			<li>Added <kbd>strip_quotes()</kbd> function to <a href="./helpers/string_helper.html">string helper</a>.</li>
+			<li>Added <kbd>reduce_multiples()</kbd> function to <a href="./helpers/string_helper.html">string helper</a>.</li>
+			<li>Added <kbd>quotes_to_entities()</kbd> function to <a href="./helpers/string_helper.html">string helper</a>.</li>
+			<li>Added <kbd>form_fieldset()</kbd>, <kbd>form_fieldset_close()</kbd>, <kbd>form_label()</kbd>, and <kbd>form_reset()</kbd> function to <a href="./helpers/form_helper.html">form helper</a>.</li>
+			<li>Added support for external urls in <kbd>form_open()</kbd>.</li>
+			<li>Removed support for db_backup in MySQLi due to incompatible functions.</li>
+			<li>Javascript Calendar plugin now uses the months and days from the calendar language file, instead of hard-coded values, internationalizing it.</li>
 		</ul>
 	</li>
 	
-      
-    <li>Documentation Changes
+	  
+	<li>Documentation Changes
 		<ul>
 			<li>Added <a href="./doc_style/index.html">Writing Documentation</a> section for the community to use in writing their own documentation.</li>
 			<li>Added titles to all user manual pages.</li>
@@ -413,9 +412,9 @@
 			<li>Added <a href="http://codeigniter.com/user_guide/libraries/zip.html">Zip Encoding Class</a> to the table of contents of the userguide.</li>
 			<li>Moved part of the userguide menu javascript to an external file.</li>
 			<li>Documented <kbd>distinct()</kbd> in <a href="./database/active_record.html">Active Record</a>. </li>
-		    <li>Documented the <kbd>timezones()</kbd> function in the <a href="./helpers/date_helper.html">Date Helper</a>.</li>
-		    <li>Documented unset_userdata in the <a href="./libraries/sessions.html">Session class</a>.</li>
-		    <li>Documented 2 config options to the <a href="./database/configuration.html">Database configuration</a> page.</li>
+			<li>Documented the <kbd>timezones()</kbd> function in the <a href="./helpers/date_helper.html">Date Helper</a>.</li>
+			<li>Documented unset_userdata in the <a href="./libraries/sessions.html">Session class</a>.</li>
+			<li>Documented 2 config options to the <a href="./database/configuration.html">Database configuration</a> page.</li>
 		</ul>
 	</li>
 </ul>
@@ -430,62 +429,62 @@
 	<li>Fixed a bug (#2542)in the clean_email() method of the Email class to allow for non-numeric / non-sequential array keys.</li>
 	<li>Fixed a bug (#2545) in <kbd>_html_entity_decode_callback()</kbd> when 'global_xss_filtering' is enabled.</li>
 	<li>Fixed a bug (#2668) in the <a href="./libraries/parser.html">parser class</a> where numeric data was ignored.</li>
-    <li>Fixed a bug (#2679) where the &quot;previous&quot; pagination link would get drawn on the first page.</li>
+	<li>Fixed a bug (#2679) where the &quot;previous&quot; pagination link would get drawn on the first page.</li>
 	<li>Fixed a bug (#2702) in _object_to_array that broke some types of inserts and updates.</li>
-    <li>Fixed a bug (#2732) in the SQLite driver for PHP 4.</li>
-    <li>Fixed a bug (#2754) in Pagination to scan for non-positive num_links.</li>
-    <li>Fixed a bug (#2762) in the <a href="./libraries/sessions.html">Session library</a> where user agent matching would fail on user agents ending with a space. </li>
-    <li>Fixed a bug (#2784) $field_names[] vs $Ffield_names[] in postgre and sqlite drivers.</li>
-    <li>Fixed a bug (#2810) in the typography helper causing extraneous paragraph tags when string contains tags.</li>
+	<li>Fixed a bug (#2732) in the SQLite driver for PHP 4.</li>
+	<li>Fixed a bug (#2754) in Pagination to scan for non-positive num_links.</li>
+	<li>Fixed a bug (#2762) in the <a href="./libraries/sessions.html">Session library</a> where user agent matching would fail on user agents ending with a space. </li>
+	<li>Fixed a bug (#2784) $field_names[] vs $Ffield_names[] in postgre and sqlite drivers.</li>
+	<li>Fixed a bug (#2810) in the typography helper causing extraneous paragraph tags when string contains tags.</li>
 	<li>Fixed a bug (#2849) where arguments passed to a subfolder controller method would be incorrectly shifted, dropping the 3rd segment value.</li>
-    <li>Fixed a bug (#2858) which referenced a wrong variable in the Image class.</li>
-    <li>Fixed a bug (#2875)when loading plugin files as _plugin. and not _pi.</li>
-    <li>Fixed a bug (#2912) in <kbd>get_filenames()</kbd> in the <a href="./helpers/file_helper.html">File Helper </a>where the array wasn't cleared after each call.</li>
-    <li>Fixed a bug (#2974) in <kbd>highlight_phrase()</kbd> that caused an error with slashes.</li>
-    <li>Fixed a bug (#3003) in the Encryption Library to support modes other than MCRYPT_MODE_ECB</li>
-    <li>Fixed a bug (#3015) in the <a href="./libraries/user_agent.html">User Agent library</a> where more then 2 languages where not reported with languages().</li>
-    <li>Fixed a bug (#3017) in the <a href="./libraries/email.html">Email</a> library where some timezones were calculated incorrectly. </li>
-    <li>Fixed a bug (#3024) in which master_dim wasn't getting reset by clear() in the Image library.</li>
-    <li>Fixed a bug (#3156) in Text Helper highlight_code() causing PHP tags to be handled incorrectly.</li>
-    <li>Fixed a bug (#3166) that prevented num_rows from working in Oracle.</li>
-    <li>Fixed a bug (#3175) preventing certain libraries from working properly when autoloaded in PHP 4.</li>
-    <li>Fixed a bug (#3267) in the Typography Helper where unordered list was listed &quot;un.</li>
-    <li>Fixed a bug (#3268) where the Router could leave '/' as the path.</li>
-    <li>Fixed a bug (#3279) where the Email class was sending the wrong Content-Transfer-Encoding for some character sets.</li>
-    <li>Fixed a bug (#3284) where the rsegment array would not be set properly if the requested URI contained more segments than the routed URI.</li>
-    <li>Removed extraneous load of $CFG in _display_cache() of the Output class (#3285).</li>
-    <li>Removed an extraneous call to loading models (#3286).</li>
-    <li>Fixed a bug (#3310) with sanitization of globals in the Input class that could unset CI's global variables.</li>
-    <li>Fixed a bug (#3314) which would cause the top level path to be deleted in delete_files() of the File helper.</li>
-    <li>Fixed a bug (#3328) where the smiley helper might return an undefined variable.</li>
-    <li>Fixed a bug (#3330) in the FTP class where a comparison wasn't getting made.</li>
-    <li>Removed an unused parameter from Profiler (#3332).</li>
-    <li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>
+	<li>Fixed a bug (#2858) which referenced a wrong variable in the Image class.</li>
+	<li>Fixed a bug (#2875)when loading plugin files as _plugin. and not _pi.</li>
+	<li>Fixed a bug (#2912) in <kbd>get_filenames()</kbd> in the <a href="./helpers/file_helper.html">File Helper </a>where the array wasn't cleared after each call.</li>
+	<li>Fixed a bug (#2974) in <kbd>highlight_phrase()</kbd> that caused an error with slashes.</li>
+	<li>Fixed a bug (#3003) in the Encryption Library to support modes other than MCRYPT_MODE_ECB</li>
+	<li>Fixed a bug (#3015) in the <a href="./libraries/user_agent.html">User Agent library</a> where more then 2 languages where not reported with languages().</li>
+	<li>Fixed a bug (#3017) in the <a href="./libraries/email.html">Email</a> library where some timezones were calculated incorrectly. </li>
+	<li>Fixed a bug (#3024) in which master_dim wasn't getting reset by clear() in the Image library.</li>
+	<li>Fixed a bug (#3156) in Text Helper highlight_code() causing PHP tags to be handled incorrectly.</li>
+	<li>Fixed a bug (#3166) that prevented num_rows from working in Oracle.</li>
+	<li>Fixed a bug (#3175) preventing certain libraries from working properly when autoloaded in PHP 4.</li>
+	<li>Fixed a bug (#3267) in the Typography Helper where unordered list was listed &quot;un.</li>
+	<li>Fixed a bug (#3268) where the Router could leave '/' as the path.</li>
+	<li>Fixed a bug (#3279) where the Email class was sending the wrong Content-Transfer-Encoding for some character sets.</li>
+	<li>Fixed a bug (#3284) where the rsegment array would not be set properly if the requested URI contained more segments than the routed URI.</li>
+	<li>Removed extraneous load of $CFG in _display_cache() of the Output class (#3285).</li>
+	<li>Removed an extraneous call to loading models (#3286).</li>
+	<li>Fixed a bug (#3310) with sanitization of globals in the Input class that could unset CI's global variables.</li>
+	<li>Fixed a bug (#3314) which would cause the top level path to be deleted in delete_files() of the File helper.</li>
+	<li>Fixed a bug (#3328) where the smiley helper might return an undefined variable.</li>
+	<li>Fixed a bug (#3330) in the FTP class where a comparison wasn't getting made.</li>
+	<li>Removed an unused parameter from Profiler (#3332).</li>
+	<li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>
 	<li>Fixed a bug in the <a href="./libraries/file_uploading.html">upload library</a> when allowed_files wasn't defined.</li>
-    <li>Fixed a bug in <kbd>word_wrap()</kbd> of the Text Helper that incorrectly referenced an object. </li>
-    <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where <kbd>valid_ip()</kbd> wasn't called properly.</li>
-    <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where individual error messages for checkboxes wasn't supported.</li>
-    <li>Fixed a bug in captcha calling an invalid PHP function.</li>
-    <li>Fixed a bug in the cookie helper "set_cookie" function.  It was not honoring the config settings.</li>
-    <li>Fixed a bug that was making validation callbacks required even when not set as such.</li>
-    <li>Fixed a bug in the XML-RPC library so if a type is specified, a more intelligent decision is made as to the default type.</li>
-    <li>Fixed an example of comma-separated emails in the email library documentation.</li>
-    <li>Fixed an example in the Calendar library for Showing Next/Previous Month Links.</li>
-    <li>Fixed a typo in the database language file.</li>
-    <li>Fixed a typo in the image language file &quot;suppor&quot; to &quot;support&quot;.</li>
-    <li>Fixed an example for XML RPC.</li>
-    <li>Fixed an example of <kbd>accept_charset()</kbd> in the <a href="./libraries/user_agent.html">User Agent Library</a>.</li>
-    <li>Fixed a typo in the docblock comments that had CodeIgniter spelled CodeIgnitor.</li>
-    <li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid).</li>
-    <li>Fixed typos in the email Language class (email_attachment_unredable, email_filed_smtp_login), and FTP Class (ftp_unable_to_remame).</li>
-    <li>Added a stripslashes()  into the Upload Library.</li>
-    <li>Fixed a series of grammatical and spelling errors in the language files.</li>
-    <li>Fixed assorted user guide typos.</li>
+	<li>Fixed a bug in <kbd>word_wrap()</kbd> of the Text Helper that incorrectly referenced an object. </li>
+	<li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where <kbd>valid_ip()</kbd> wasn't called properly.</li>
+	<li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where individual error messages for checkboxes wasn't supported.</li>
+	<li>Fixed a bug in captcha calling an invalid PHP function.</li>
+	<li>Fixed a bug in the cookie helper "set_cookie" function.  It was not honoring the config settings.</li>
+	<li>Fixed a bug that was making validation callbacks required even when not set as such.</li>
+	<li>Fixed a bug in the XML-RPC library so if a type is specified, a more intelligent decision is made as to the default type.</li>
+	<li>Fixed an example of comma-separated emails in the email library documentation.</li>
+	<li>Fixed an example in the Calendar library for Showing Next/Previous Month Links.</li>
+	<li>Fixed a typo in the database language file.</li>
+	<li>Fixed a typo in the image language file &quot;suppor&quot; to &quot;support&quot;.</li>
+	<li>Fixed an example for XML RPC.</li>
+	<li>Fixed an example of <kbd>accept_charset()</kbd> in the <a href="./libraries/user_agent.html">User Agent Library</a>.</li>
+	<li>Fixed a typo in the docblock comments that had CodeIgniter spelled CodeIgnitor.</li>
+	<li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid).</li>
+	<li>Fixed typos in the email Language class (email_attachment_unredable, email_filed_smtp_login), and FTP Class (ftp_unable_to_remame).</li>
+	<li>Added a stripslashes()  into the Upload Library.</li>
+	<li>Fixed a series of grammatical and spelling errors in the language files.</li>
+	<li>Fixed assorted user guide typos.</li>
 </ul>
 <h2>Version 1.5.4</h2>
 <p>Release Date: July 12, 2007 </p>
 <ul>
-    <li>Added <a href="./libraries/language.html">custom Language files</a> to the <a href="./general/autoloader.html">autoload</a> options. </li>
+	<li>Added <a href="./libraries/language.html">custom Language files</a> to the <a href="./general/autoloader.html">autoload</a> options. </li>
 	<li>Added stripslashes() to the _clean_input_data() function in the <a href="./libraries/input.html">Input class</a> when magic quotes is on so that data will always be un-slashed within the framework.</li>
 	<li>Added array to string into the <a href="general/profiling.html">profiler</a>.</li>
 	<li>Added some additional mime types in application/config/mimes.php.</li>
@@ -497,10 +496,10 @@
 	<li>Fixed a bug that was allowing multiple load attempts on extended classes.</li>
 	<li>Fixed a bug in the bootstrap file that was incorrectly attempting to discern the full server path even when it was explicity set by the user.</li>
 	<li>Fixed a bug in the escape_str() function in the MySQL driver.</li>
-    <li>Fixed a typo in the <a href="./libraries/calendar.html">Calendar library </a> </li>
-    <li>Fixed a typo in rpcs.php library</li>
-    <li>Fixed a bug in the <a href="./libraries/zip.html">Zip library</a>, providing PC Zip file compatibility with Mac OS X</li>
-    <li>Fixed a bug in router that was ignoring the scaffolding route for optimization </li>
+	<li>Fixed a typo in the <a href="./libraries/calendar.html">Calendar library </a> </li>
+	<li>Fixed a typo in rpcs.php library</li>
+	<li>Fixed a bug in the <a href="./libraries/zip.html">Zip library</a>, providing PC Zip file compatibility with Mac OS X</li>
+	<li>Fixed a bug in router that was ignoring the scaffolding route for optimization </li>
 	<li>Fixed an IP validation bug.</li>
 	<li>Fixed a bug in display of POST keys in the <a href="./general/profiling.html">Profiler</a> output</li>
 	<li>Fixed a bug in display of queries with characters that would be interpreted as HTML in the <a href="./general/profiling.html">Profiler</a> output</li>
@@ -511,59 +510,59 @@
 	<li>Fixed various doc typos. </li>
 	<li>Documented two functions from the <a href="./helpers/string_helper.html">String helper </a> that were missing from the user guide:  trim_slashes() and reduce_double_slashes().</li>
 	<li>Docs now validate to XHTML 1 transitional</li>
-    <li>Updated the XSS Filtering to take into account the IE expression() ability and improved certain deletions to prevent possible exploits</li>
-    <li>Modified the Router so that when Query Strings are Enabled, the controller trigger and function trigger values are sanitized for filename include security.</li>
-    <li>Modified the is_image() method in the Upload library to take into account Windows IE 6/7 eccentricities when dealing with MIMEs</li>
-    <li>Modified XSS Cleaning routine to be more performance friendly and compatible with PHP 5.2's new PCRE backtrack and recursion limits.</li>
+	<li>Updated the XSS Filtering to take into account the IE expression() ability and improved certain deletions to prevent possible exploits</li>
+	<li>Modified the Router so that when Query Strings are Enabled, the controller trigger and function trigger values are sanitized for filename include security.</li>
+	<li>Modified the is_image() method in the Upload library to take into account Windows IE 6/7 eccentricities when dealing with MIMEs</li>
+	<li>Modified XSS Cleaning routine to be more performance friendly and compatible with PHP 5.2's new PCRE backtrack and recursion limits.</li>
 	<li>Modified the <a href="./helpers/url_helper.html">URL Helper</a> to type cast the $title as a string in case a numeric value is supplied</li>
 	<li>Modified Form Helper form_dropdown() to type cast the keys and values of the options array as strings, allowing numeric values to be properly set as 'selected'</li>
 	<li>Deprecated the use if <kbd>is_numeric()</kbd> in various places since it allows periods.  Due to compatibility problems with <kbd>ctype_digit()</kbd>, making it unreliable in some installations, the following regular expression was used instead:  <kbd>preg_match("/[^0-9]/", $n)</kbd></li>
-    <li>Deprecated: APPVER has been deprecated and replaced with CI_VERSION for clarity. </li>
+	<li>Deprecated: APPVER has been deprecated and replaced with CI_VERSION for clarity. </li>
 </ul>
 <h2>Version 1.5.3</h2>
 <p>Release Date: April 15, 2007 </p>
 <ul>
-    <li>Added array to string into the profiler </li>
-    <li>Code Igniter references updated to CodeIgniter </li>
-    <li>pMachine references updated to EllisLab </li>
-    <li>Fixed a bug in the repeater function of <a href="./helpers/string_helper.html">string helper</a>. </li>
-    <li>Fixed a bug in ODBC driver </li>
-    <li>Fixed a bug in result_array() that was returning an empty array when no result is produced.</li>
-    <li>Fixed a bug in the redirect function of the <a href="./helpers/url_helper.html">url helper</a>. </li>
-    <li>Fixed an undefined variable in Loader </li>
-    <li>Fixed a version bug in the Postgre driver </li>
-    <li>Fixed a bug in the textarea function of the form helper for use with strings</li>
-    <li>Fixed doc typos. </li>
+	<li>Added array to string into the profiler </li>
+	<li>Code Igniter references updated to CodeIgniter </li>
+	<li>pMachine references updated to EllisLab </li>
+	<li>Fixed a bug in the repeater function of <a href="./helpers/string_helper.html">string helper</a>. </li>
+	<li>Fixed a bug in ODBC driver </li>
+	<li>Fixed a bug in result_array() that was returning an empty array when no result is produced.</li>
+	<li>Fixed a bug in the redirect function of the <a href="./helpers/url_helper.html">url helper</a>. </li>
+	<li>Fixed an undefined variable in Loader </li>
+	<li>Fixed a version bug in the Postgre driver </li>
+	<li>Fixed a bug in the textarea function of the form helper for use with strings</li>
+	<li>Fixed doc typos. </li>
 </ul>
 <h2>Version 1.5.2</h2>
 <p>Release Date: February 13, 2007 </p>
 <ul>
-    <li>Added <a href="./installation/downloads.html#svn">subversion information</a> to the <a href="./installation/downloads.html">downloads</a> page. </li>
+	<li>Added <a href="./installation/downloads.html#svn">subversion information</a> to the <a href="./installation/downloads.html">downloads</a> page. </li>
 	<li>Added support for captions in the <a href="./libraries/table.html">Table Library</a> </li>
 	<li>Fixed a bug in the <a href="./helpers/download_helper.html">download_helper</a> that was causing Internet Explorer to load rather then download </li>
-    <li>Fixed a bug in the Active Record Join function that was not taking table prefixes into consideration.</li>
-    <li>Removed unescaped variables in error messages of Input and Router classes</li>
-    <li>Fixed a bug in the Loader that was causing errors on Libraries loaded twice. A debug message is now silently made in the log.  </li>
-    <li>Fixed a bug in the <a href="./helpers/form_helper.html">form helper</a> that gave textarea a value attribute </li>
-    <li>Fixed a bug in the <a href="./libraries/image_lib.php">Image Library</a> that was ignoring resizing the same size image </li>
-    <li>Fixed some doc typos.</li>
+	<li>Fixed a bug in the Active Record Join function that was not taking table prefixes into consideration.</li>
+	<li>Removed unescaped variables in error messages of Input and Router classes</li>
+	<li>Fixed a bug in the Loader that was causing errors on Libraries loaded twice. A debug message is now silently made in the log.  </li>
+	<li>Fixed a bug in the <a href="./helpers/form_helper.html">form helper</a> that gave textarea a value attribute </li>
+	<li>Fixed a bug in the <a href="./libraries/image_lib.php">Image Library</a> that was ignoring resizing the same size image </li>
+	<li>Fixed some doc typos.</li>
 </ul>
 
 
 <h2>Version 1.5.1</h2>
 <p>Release Date: November 23, 2006</p>
 <ul>
-    <li>Added support for submitting arrays of libraries in the $this-&gt;load-&gt;library function.</li>
-    <li>Added support for naming custom library files in lower or uppercase.</li>
-    <li>Fixed a bug related to output buffering.</li>
-    <li>Fixed a bug in the active record class that was not resetting query data after a completed query.</li>
-    <li>Fixed a bug that was suppressing errors in controllers.</li>
-    <li>Fixed a problem that can cause a loop to occur when the config file is missing.</li>
-    <li>Fixed a bug that occurred when multiple models were loaded with the third parameter set to TRUE.</li>
-    <li>Fixed an oversight that was not unsetting globals properly in the input sanitize function.</li>
-    <li>Fixed some bugs in the Oracle DB driver.</li>
-    <li>Fixed an incorrectly named variable in the MySQLi result driver.</li>
-    <li>Fixed some doc typos.</li>
+	<li>Added support for submitting arrays of libraries in the $this-&gt;load-&gt;library function.</li>
+	<li>Added support for naming custom library files in lower or uppercase.</li>
+	<li>Fixed a bug related to output buffering.</li>
+	<li>Fixed a bug in the active record class that was not resetting query data after a completed query.</li>
+	<li>Fixed a bug that was suppressing errors in controllers.</li>
+	<li>Fixed a problem that can cause a loop to occur when the config file is missing.</li>
+	<li>Fixed a bug that occurred when multiple models were loaded with the third parameter set to TRUE.</li>
+	<li>Fixed an oversight that was not unsetting globals properly in the input sanitize function.</li>
+	<li>Fixed some bugs in the Oracle DB driver.</li>
+	<li>Fixed an incorrectly named variable in the MySQLi result driver.</li>
+	<li>Fixed some doc typos.</li>
 </ul>
 <h2>Version 1.5.0.1</h2>
 <p>Release Date: October 31, 2006</p>
